package com.shl.lambda;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;

import com.sun.javafx.image.impl.IntArgb;

public class LmdTest {
	public void test2(){
	   Runnable run1=new Runnable() {
		@Override
		public void run() {
            System.out.println("匿名内部类");
		}
	};
	  Runnable run2=()->{
		  System.out.println("lambda表达式");
	  };
	  run1.run();
	  run2.run();
	}
	public void test3(){
		Comparator<Integer> com=(Integer x,Integer y)->{
			return x-y;
		};
		Comparator<Integer> com2=(x,y)->{
			return x-y;
		};
		Comparator<Integer> com3=(x,y)->x-y;
        //以下为java.util.function包中预定义的一些函数接口
		Supplier<Integer> obj=()->5;
		ToIntFunction<Integer> obj2=x->x*2;
		System.out.println(com.compare(1, 2));
		System.out.println(com2.compare(1, 2));
		System.out.println(com3.compare(1, 2));
		int i=obj.get();
		int j=obj2.applyAsInt(5);
		System.out.println(i+":"+j);
	}
	public void test4(){
		//静态方法引用
		Comparator<Integer> com=(x,y)->Integer.compare(x, y);
		Comparator<Integer> com2=Integer::compare;
		List<Person> persons=Arrays.asList(new Person(),new Person(),new Person());
		//forEach方法接受一个lambda表达式作为参数，对于list集合中每个元素都调用该表达式
		//实例方法引用
		persons.forEach(person->person.getFood());
		persons.forEach(Person::getFood);
		//父类方法引用
		persons.forEach(person->person.eat());
		persons.forEach(Human::eat);
        List<Integer> ages=Arrays.asList(1,2,3,4,5);
        //构造方法引用
        ages.forEach(x->new Integer(x));
        ages.forEach(Integer::new);
        //数组构造方法引用
        IntFunction<Integer[]> a=x->new Integer[x];
        IntFunction<Integer[]> a2=Integer[]::new;
        a.apply(10);
        a2.apply(10);
	}
	private int a=1;
	private static int b=2; 
	private int d=2;
	public void test5(int c){
	  int c2=1;
	  final int c3=1;
      IntFunction<Integer> f=x->x+a;
      IntFunction<Integer> f2=x->x+b;
      IntFunction<Integer> f3=x->{
    	 //lambda表达式中不能修改其引用的外部方法的局部变量，一旦被lambda表达式引用，该变量在整个方法体中
    	  //同样不能被修改，否则报错
    	  b++;
//    	  c2++;
//    	  c++;
    	  int d=2;
    	  //不能其被定义的外部方法中的局部变量相同的变量，但可以与类中成员变量同名
//    	  int c2=3;
//    	  int c=2;
    	  return b+x+c2;
      };
      IntFunction<Integer> f4=x->{
    	  a++;
    	  return a+x;
      };
//      c2=3;
	}
	public void test6(){
		Runnable run=()->{
			System.out.println(this);
		};
		Runnable run2=()->{
			System.out.println(toString()+getName());
		};
		run.run();
		run2.run();
	}
	@Override
	public String toString() {
		return "helloworld";
	}
	private String getName(){
		return "shl";
	}
	public void test7(){
		
	}
	public void test(){
		
	}
	public static void main(String[] args) {
		new LmdTest().test6();
	}
}
